package com.basic.modules.ykf.controller;

import java.util.*;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.date.DateField;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.aliyuncs.exceptions.ClientException;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.basic.common.annotation.StringTrim;
import com.basic.common.exception.RRException;
import com.basic.common.utils.CommonUtils;
import com.basic.common.utils.ParamsModel;
import com.basic.common.validator.ValidatorUtils;
import com.basic.modules.sys.entity.SysUserEntity;
import com.basic.modules.sys.service.SysUserService;
import com.basic.modules.ykf.entity.*;
import com.basic.modules.ykf.model.SubAccountModel;
import com.basic.modules.ykf.model.SumSubAccountModel;
import com.basic.modules.ykf.service.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import com.basic.common.utils.PageUtils;
import com.basic.common.utils.R;


/**
 * 店铺子账号
 *
 * @author maoheng
 * @email 15738859597@163.com
 * @date 2024-05-15 15:36:23
 */
@RestController
@RequestMapping("ykf/customerSubAccount")
public class YkfCustomerSubAccountController {

    @Autowired
    private YkfCustomerSubAccountService ykfCustomerSubAccountService;

    @Autowired
    private YkfCustomerShopService shopService;

    @Autowired
    private YkfCustomerService customerService;

    @Autowired
    private SysUserService sysUserService;

    @Autowired
    private YkfSubAccountRecordService subAccountRecordService;

    @Autowired
    private YkfMsgRecordService recordService;

    @Autowired
    private SmsService smsService;

    @Autowired
    private YkfSubAccountModifyRecordService modifyRecordService;

    @Autowired
    private YkfAccountInputRecordService inputRecordService;


    /**
     * 列表-分页
     */
    @StringTrim
    @PostMapping("/page")
    public R list(@RequestBody ParamsModel<YkfCustomerSubAccountEntity> params) {
        PageUtils page = ykfCustomerSubAccountService.queryPage(params);
        return R.ok(page);
    }


    /**
     * 列表-分页
     */
    @StringTrim
    @PostMapping("/page2")
    public R list2(@RequestBody ParamsModel<YkfCustomerSubAccountEntity> params) {
        PageUtils page = ykfCustomerSubAccountService.queryPage2(params);
        return R.ok(page);
    }


    /**
     * 列表-分页
     */
    @StringTrim
    @PostMapping("/page3")
    public R list3(@RequestBody ParamsModel<YkfCustomerSubAccountEntity> params) {
        PageUtils page = ykfCustomerSubAccountService.queryPage3(params);
        return R.ok(page);
    }

    /**
     * 列表-分页
     */
    @StringTrim
    @PostMapping("/page4")
    public R list4(@RequestBody ParamsModel<YkfCustomerSubAccountEntity> params) {
        PageUtils page = ykfCustomerSubAccountService.queryPage4(params);
        return R.ok(page);
    }


    /**
     * 子账号分配列表-分页
     */
    @StringTrim
    @PostMapping("/distributeCusSerPage")
    public R distributeCusSerPage(@RequestBody ParamsModel<YkfCustomerSubAccountEntity> params) {
        PageUtils page = ykfCustomerSubAccountService.distributeCusSerPage(params);
        return R.ok(page);
    }


    /**
     * 列表-查询分页
     */
    @StringTrim
    @PostMapping("/selectPage")
    public R selectPage(@RequestBody ParamsModel<YkfCustomerSubAccountEntity> params) {
        PageUtils page = ykfCustomerSubAccountService.selectPage(params);
        return R.ok(page);
    }

    /**
     * 列表-分页
     */
    @StringTrim
    @PostMapping("/stopPage")
    public R stopPage(@RequestBody ParamsModel<YkfCustomerSubAccountEntity> params) {
        PageUtils page = ykfCustomerSubAccountService.stopPage(params);
        return R.ok(page);
    }

    /**
     * 子账号在线列表-分页
     */
    @StringTrim
    @PostMapping("/onLinePage")
    public R onLinePage(@RequestBody ParamsModel<YkfCustomerSubAccountEntity> params) {
        PageUtils page = ykfCustomerSubAccountService.onLinePage(params);
        return R.ok(page);
    }


    /**
     * 信息
     */
    @PostMapping("/info")
    public R info(@RequestBody YkfCustomerSubAccountEntity params) {
        if (ObjectUtil.isEmpty(params) || ObjectUtil.isEmpty(params.getSubAccountId())) {
            throw new RRException("参数缺失");
        }
        return R.ok(ykfCustomerSubAccountService.getById(params.getSubAccountId()));
    }

    /**
     * 保存
     */
    @PostMapping("/save")
    public R save(@RequestBody SubAccountModel subAccountModel) {
        ValidatorUtils.validateEntity(subAccountModel);
        ykfCustomerSubAccountService.saveSubAccount(subAccountModel);
        return R.ok();
    }

    /**
     * 添加子账号
     */
    @PostMapping("/addSubAccount")
    public R addSubAccount(@RequestBody YkfCustomerSubAccountEntity subAccount) {
        // (1) 校验,店铺ID、子账号名称、子账号密码不能为空
        if (ObjectUtil.isNotEmpty(subAccount.getShopId()) && StrUtil.isNotBlank(subAccount.getAccountNo()) && StrUtil.isNotBlank(subAccount.getAccountPassword())) {

            // (2) 校验,同一个店铺同一个数据账号不能重复
            QueryWrapper<YkfCustomerSubAccountEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().eq(YkfCustomerSubAccountEntity::getShopId, subAccount.getShopId())
                    .eq(YkfCustomerSubAccountEntity::getAccountNo, subAccount.getAccountNo());
            if (ykfCustomerSubAccountService.count(queryWrapper) > 0) {
                throw new RRException("数据账号" + subAccount.getAccountNo() + "已存在，请检查");
            }

            // (3) 校验,同一个店铺同一个子账号名称不能重复
            QueryWrapper<YkfCustomerSubAccountEntity> queryWrapper2 = new QueryWrapper<>();
            queryWrapper2.lambda().eq(YkfCustomerSubAccountEntity::getShopId, subAccount.getShopId())
                    .eq(YkfCustomerSubAccountEntity::getAccountName, subAccount.getAccountName());
            if (ykfCustomerSubAccountService.count(queryWrapper2) > 0) {
                throw new RRException("子账号名称" + subAccount.getAccountName() + "已存在，请检查");
            }

            // 获取店铺ID
            YkfCustomerShopEntity shop = shopService.getById(subAccount.getShopId());
            // 校验店铺不等于空
            if (ObjectUtil.isNotEmpty(shop)) {
                // 获取店铺名称
                subAccount.setShopName(shop.getShopName());
                // 获取店铺编号
                subAccount.setShopNo(shop.getShopNo());
                // 获取店铺底薪
                subAccount.setBaseSalary(shop.getBaseSalary());
                // 判断该店铺的客户ID是否为空
                if (ObjectUtil.isNotEmpty(shop.getCustomerId())) {
                    // 找到客户对象
                    YkfCustomerEntity customerEntity = customerService.getById(shop.getCustomerId());
                    // 判断对象是否为空
                    if (ObjectUtil.isNotEmpty(customerEntity)) {
                        // 客户ID set进子账号对象
                        subAccount.setCustomerId(customerEntity.getCustomerId());
                        // 客户名称 set进子账号对象
                        subAccount.setCustomerName(customerEntity.getCustomerName());
                    }
                }
            }
            // 状态字段改为1(启用)
            subAccount.setStatus(1);
            // insert进子账号表
            ykfCustomerSubAccountService.save(subAccount);
        } else {
            throw new RRException("参数缺失");
        }
        return R.ok();
    }

    /**
     * 修改
     */
    @PostMapping("/update")
    public R update(@RequestBody YkfCustomerSubAccountEntity ykfCustomerSubAccount) {
//        validAccount(ykfCustomerSubAccount);
        YkfCustomerSubAccountEntity subAccount = ykfCustomerSubAccountService.getById(ykfCustomerSubAccount.getSubAccountId());
        QueryWrapper<YkfCustomerSubAccountEntity> queryWrapper1 = new QueryWrapper<>();
        queryWrapper1.lambda().eq(YkfCustomerSubAccountEntity::getAccountNo, ykfCustomerSubAccount.getAccountNo())
                .ne(YkfCustomerSubAccountEntity::getAccountNo, subAccount.getAccountNo());
        if (ykfCustomerSubAccountService.count(queryWrapper1) > 0) {
            throw new RRException("数据账号" + ykfCustomerSubAccount.getAccountNo() + "已存在，请检查");
        }
        QueryWrapper<YkfCustomerSubAccountEntity> queryWrapper2 = new QueryWrapper<>();
        queryWrapper2.lambda().eq(YkfCustomerSubAccountEntity::getAccountName, ykfCustomerSubAccount.getAccountName())
                .ne(YkfCustomerSubAccountEntity::getAccountNo, subAccount.getAccountNo());
        if (ykfCustomerSubAccountService.count(queryWrapper2) > 0) {
            throw new RRException("子账号名称" + ykfCustomerSubAccount.getAccountName() + "已存在，请检查");
        }
        UpdateWrapper<YkfCustomerSubAccountEntity> updateWrapper = new UpdateWrapper<>();
        updateWrapper.lambda().eq(YkfCustomerSubAccountEntity::getAccountNo, subAccount.getAccountNo())
                .set(YkfCustomerSubAccountEntity::getAccountNo, ykfCustomerSubAccount.getAccountNo())
                .set(YkfCustomerSubAccountEntity::getAccountName, ykfCustomerSubAccount.getAccountName())
                .set(YkfCustomerSubAccountEntity::getAccountPassword, ykfCustomerSubAccount.getAccountPassword())
                .set(YkfCustomerSubAccountEntity::getInputType, ykfCustomerSubAccount.getInputType());
        ykfCustomerSubAccountService.update(new YkfCustomerSubAccountEntity(), updateWrapper);

        UpdateWrapper<YkfAccountInputRecordEntity> updateWrapper1 = new UpdateWrapper<>();
        updateWrapper1.lambda().eq(YkfAccountInputRecordEntity::getAccountNo, subAccount.getAccountNo())
                .set(YkfAccountInputRecordEntity::getAccountNo, ykfCustomerSubAccount.getAccountNo())
                .set(YkfAccountInputRecordEntity::getAccountName, ykfCustomerSubAccount.getAccountName());
        inputRecordService.update(new YkfAccountInputRecordEntity(), updateWrapper1);
        return R.ok();
    }

    private void validAccount(YkfCustomerSubAccountEntity ykfCustomerSubAccount) {
        QueryWrapper<YkfCustomerSubAccountEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId())
                .eq(YkfCustomerSubAccountEntity::getAccountNo, ykfCustomerSubAccount.getAccountNo());
        if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getSubAccountId())) {
            queryWrapper.lambda().ne(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId());
        }
        if (ykfCustomerSubAccountService.count(queryWrapper) > 0) {
            throw new RRException("账号重复,请检查");
        }
    }

    /**
     * 删除
     */
    @PostMapping("/delete")
    public R delete(@RequestBody Long[] subAccountIds) {
        for (Long subAccountId : subAccountIds) {
            YkfCustomerSubAccountEntity subAccount = ykfCustomerSubAccountService.getById(subAccountId);
            //查询是否存在记录
            if (ObjectUtil.isNotEmpty(subAccount.getStartDate()) && ObjectUtil.isNotEmpty(subAccount.getEndDate())) {
                QueryWrapper<YkfAccountInputRecordEntity> queryWrapper = new QueryWrapper<>();
                //查询6个月之前的时间
                DateTime offset = DateUtil.offset(DateUtil.date(), DateField.MONTH, -6);
                queryWrapper.lambda().eq(YkfAccountInputRecordEntity::getSubAccountId, subAccountId)
                        .ge(YkfAccountInputRecordEntity::getDate, subAccount.getStartDate().compareTo(offset) > 0 ? subAccount.getStartDate() : offset)
                        .le(YkfAccountInputRecordEntity::getDate, subAccount.getEndDate());
                if (inputRecordService.count(queryWrapper) > 0) {
                    throw new RRException("最近6个月有数据不可以删除");
                }
            }
        }
        ykfCustomerSubAccountService.removeByIds(Arrays.asList(subAccountIds));
        return R.ok();
    }

    /**
     * 修改状态 2-停用/1-启用
     */
    @PostMapping("/updateStatus")
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public R updateStatus(@RequestBody YkfCustomerSubAccountEntity ykfCustomerSubAccount) throws ClientException {
        if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount) && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getSubAccountId())) {
            if (ykfCustomerSubAccount.getStatus() == 2) {
                YkfCustomerSubAccountEntity subAccountById = ykfCustomerSubAccountService.getById(ykfCustomerSubAccount.getSubAccountId());
                //查询店铺所有子账号分配记录
                QueryWrapper<YkfCustomerSubAccountEntity> subAccountEntityQueryWrapper = new QueryWrapper<>();
                subAccountEntityQueryWrapper.lambda().eq(YkfCustomerSubAccountEntity::getAccountNo, subAccountById.getAccountNo())
                        .orderByDesc(YkfCustomerSubAccountEntity::getStartDate);
                List<YkfCustomerSubAccountEntity> list = ykfCustomerSubAccountService.list(subAccountEntityQueryWrapper);
                if (ObjectUtil.isNotEmpty(list)) {
                    Date startDate = list.get(0).getStartDate();
                    if (ObjectUtil.isNotEmpty(startDate) && ykfCustomerSubAccount.getStopTime().compareTo(startDate) < 0) {
                        throw new RRException("停止日期需大于最后一条子账号分配记录的开始日期，请检查");
                    }
                    for (int i = 0; i < list.size(); i++) {
                        SysUserEntity user = CommonUtils.getUser();
                        UpdateWrapper<YkfCustomerSubAccountEntity> updateWrapper = new UpdateWrapper<>();
                        updateWrapper.lambda().eq(YkfCustomerSubAccountEntity::getSubAccountId, list.get(i).getSubAccountId())
                                .set(YkfCustomerSubAccountEntity::getStatus, 2)
                                .set(YkfCustomerSubAccountEntity::getStopUserId, user.getUserId())
                                .set(YkfCustomerSubAccountEntity::getStopUserName, user.getName())
                                .set(YkfCustomerSubAccountEntity::getStopTime, ykfCustomerSubAccount.getStopTime());
                        if (i == 0) {
                            updateWrapper.lambda().set(YkfCustomerSubAccountEntity::getEndDate, ykfCustomerSubAccount.getStopTime());
                        }
                        ykfCustomerSubAccountService.update(new YkfCustomerSubAccountEntity(), updateWrapper);
                    }
                }
                //停用通知
                YkfCustomerSubAccountEntity subAccount = ykfCustomerSubAccountService.getById(ykfCustomerSubAccount.getSubAccountId());
                if (ObjectUtil.isNotEmpty(subAccount) && ObjectUtil.isNotEmpty(subAccount.getUserId())) {
                    SysUserEntity user = sysUserService.getById(subAccount.getUserId());
                    if (ObjectUtil.isNotEmpty(user) && StrUtil.isNotBlank(user.getMobile())) {
                        //短信
                        Map<String, String> map = new HashMap<>();
                        map.put("p0", subAccount.getFlowerName());
                        map.put("p1", subAccount.getAccountName());
                        map.put("p2", ObjectUtil.isNotEmpty(subAccount.getEndDate()) ? DateUtil.formatDate(subAccount.getEndDate()) : "");
                        smsService.sendMsg(user.getMobile(), "SMS_163625667", map);
                    }
                }
            } else {
                UpdateWrapper<YkfCustomerSubAccountEntity> updateWrapper = new UpdateWrapper<>();
                updateWrapper.lambda().eq(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId())
                        .set(YkfCustomerSubAccountEntity::getStatus, ykfCustomerSubAccount.getStatus());
                ykfCustomerSubAccountService.update(new YkfCustomerSubAccountEntity(), updateWrapper);
            }


//            UpdateWrapper<YkfCustomerSubAccountEntity> updateWrapper = new UpdateWrapper<>();
//            updateWrapper.lambda().eq(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId())
//                    .set(YkfCustomerSubAccountEntity::getStatus, ykfCustomerSubAccount.getStatus());
//            if (ykfCustomerSubAccount.getStatus() == 2) {
//                SysUserEntity user = CommonUtils.getUser();
//                updateWrapper.lambda().set(YkfCustomerSubAccountEntity::getStopUserId, user.getUserId())
//                        .set(YkfCustomerSubAccountEntity::getStopUserName, user.getName());
//                if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getStopTime())) {
//                    updateWrapper.lambda().set(YkfCustomerSubAccountEntity::getStopTime, ykfCustomerSubAccount.getStopTime());
//                } else {
//                    updateWrapper.lambda().set(YkfCustomerSubAccountEntity::getStopTime, DateUtil.date());
//                }
//            }

        } else {
            throw new RRException("参数缺失");
        }
        return R.ok();
    }

    /**
     * 设置在线状态
     */
    @PostMapping("/setOnLineStatus")
    public R setOnLineStatus(@RequestBody YkfCustomerSubAccountEntity ykfCustomerSubAccount) {
        if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount) && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getSubAccountId())) {
            UpdateWrapper<YkfCustomerSubAccountEntity> updateWrapper = new UpdateWrapper<>();
            updateWrapper.lambda().eq(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId())
                    .set(YkfCustomerSubAccountEntity::getOnLineStatus, ykfCustomerSubAccount.getOnLineStatus());
            ykfCustomerSubAccountService.update(new YkfCustomerSubAccountEntity(), updateWrapper);
        } else {
            throw new RRException("参数缺失");
        }
        return R.ok();
    }

    /**
     * 查询分配信息
     */
    @PostMapping("/getDistributeDateInfo")
    public R getDistributeInfo(@RequestBody YkfCustomerSubAccountEntity subAccount) throws ClientException {
        Map<String, String> map = new HashMap<>();
        map.put("startDate", DateUtil.today());
        map.put("endDate", "2188-01-01");
        //查询子账号详情
        if (ObjectUtil.isNotEmpty(subAccount) && StrUtil.isNotBlank(subAccount.getAccountNo())) {
            QueryWrapper<YkfCustomerSubAccountEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().eq(YkfCustomerSubAccountEntity::getAccountNo, subAccount.getAccountNo())
                    .orderByDesc(YkfCustomerSubAccountEntity::getStartDate)
                    .last("limit 1");
            YkfCustomerSubAccountEntity one = ykfCustomerSubAccountService.getOne(queryWrapper);
            if (ObjectUtil.isNotEmpty(one) && ObjectUtil.isNotEmpty(one.getEndDate()) && ObjectUtil.isNotEmpty(one.getStartDate())) {
                if (StrUtil.equals(DateUtil.formatDate(one.getEndDate()), "2188-01-01")) {
                    DateTime dateTime = DateUtil.offsetDay(one.getStartDate(), 1);
                    map.put("startDate", DateUtil.formatDate(dateTime));
                } else {
                    DateTime dateTime = DateUtil.offsetDay(one.getEndDate(), 1);
                    map.put("startDate", DateUtil.formatDate(dateTime));
                }
            }
        }
        return R.ok(map);
    }

    /**
     * 分配客服
     */
    @PostMapping("/distributeCusSer")
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public R distributeCusSer(@RequestBody YkfCustomerSubAccountEntity ykfCustomerSubAccount) throws ClientException {
        if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount) && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getSubAccountId())) {
            if (ObjectUtil.isNotNull(ykfCustomerSubAccount.getStartDate()) && ObjectUtil.isNull(ykfCustomerSubAccount.getEndDate())) {
                ykfCustomerSubAccount.setEndDate(DateUtil.parseDate("2188-01-01"));
            }
            YkfCustomerSubAccountEntity subAccount1 = ykfCustomerSubAccountService.getById(ykfCustomerSubAccount.getSubAccountId());
            validRepeatTime3(subAccount1, ykfCustomerSubAccount);
            Long accountId = ykfCustomerSubAccount.getSubAccountId();

            UpdateWrapper<YkfCustomerSubAccountEntity> updateWrapper = new UpdateWrapper<>();
            updateWrapper.lambda().eq(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId())
                    .set(YkfCustomerSubAccountEntity::getAllocationRuleId, ykfCustomerSubAccount.getAllocationRuleId())
                    .set(YkfCustomerSubAccountEntity::getUserId, ykfCustomerSubAccount.getUserId())
                    .set(YkfCustomerSubAccountEntity::getCompanyNo, ykfCustomerSubAccount.getCompanyNo())
                    .set(YkfCustomerSubAccountEntity::getCompanyName, ykfCustomerSubAccount.getCompanyName())
                    .set(YkfCustomerSubAccountEntity::getStartDate, ykfCustomerSubAccount.getStartDate())
                    .set(YkfCustomerSubAccountEntity::getEndDate, ykfCustomerSubAccount.getEndDate())
                    .set(YkfCustomerSubAccountEntity::getCommissionRatio, ykfCustomerSubAccount.getCommissionRatio())
                    .set(YkfCustomerSubAccountEntity::getSendSmsSign, ykfCustomerSubAccount.getSendSmsSign())
                    .set(YkfCustomerSubAccountEntity::getAllocationRuleName, ykfCustomerSubAccount.getAllocationRuleName())
                    .set(YkfCustomerSubAccountEntity::getConventionSalary, ykfCustomerSubAccount.getConventionSalary());

            SysUserEntity user1 = CommonUtils.getUser();
            updateWrapper.lambda().set(YkfCustomerSubAccountEntity::getBranchDispatchName, user1.getFlowerName());

            if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getUserId())) {
                SysUserEntity sysUser = sysUserService.getById(ykfCustomerSubAccount.getUserId());
                if (ObjectUtil.isNotEmpty(sysUser)) {
                    updateWrapper.lambda().set(YkfCustomerSubAccountEntity::getName, sysUser.getName())
                            .set(YkfCustomerSubAccountEntity::getFlowerName, sysUser.getFlowerName())
                            .set(YkfCustomerSubAccountEntity::getMobile, sysUser.getMobile())
                            .set(YkfCustomerSubAccountEntity::getCustomPostType, sysUser.getCustomPostType())
                            .set(YkfCustomerSubAccountEntity::getCustomPostTypeName, sysUser.getCustomPostTypeName());
                }
            }
            ykfCustomerSubAccountService.update(new YkfCustomerSubAccountEntity(), updateWrapper);

            YkfCustomerSubAccountEntity subAccount2 = ykfCustomerSubAccountService.getById(accountId);
            SysUserEntity user = sysUserService.getById(subAccount2.getUserId());
            if (ObjectUtil.isNotEmpty(user) && StrUtil.isNotBlank(user.getMobile())) {
                Map<String, String> map = new HashMap<>();
                map.put("p0", subAccount2.getFlowerName());
                map.put("p1", subAccount2.getShopName());
                map.put("p2", subAccount2.getPlatformName());
                map.put("p3", subAccount2.getCustomPostTypeName());
                map.put("p4", ObjectUtil.isEmpty(subAccount2.getStartDate()) ? "" : DateUtil.formatDate(subAccount2.getStartDate()));
                map.put("p5", ObjectUtil.isNull(subAccount2.getConventionSalary()) ? "0" : (subAccount2.getConventionSalary().stripTrailingZeros().toString()));
                map.put("p6", ObjectUtil.isNull(subAccount2.getCommissionRatio()) ? "0" : (subAccount2.getCommissionRatio().stripTrailingZeros().toString()));
                smsService.sendMsg(user.getMobile(), "SMS_163620721", map);
            }

            //保存记录
            Long subAccountId = ykfCustomerSubAccount.getSubAccountId();
            YkfCustomerSubAccountEntity subAccount = ykfCustomerSubAccountService.getById(subAccountId);
            YkfSubAccountRecordEntity subAccountRecord = new YkfSubAccountRecordEntity();
            BeanUtil.copyProperties(subAccount, subAccountRecord);
            subAccountRecord.setCreateTime(DateUtil.date());
            subAccountRecordService.save(subAccountRecord);

            //更新数据记录至新的分配记录里
            //查询子账号一样的分配记录
            UpdateWrapper<YkfAccountInputRecordEntity> updateWrapper1 = new UpdateWrapper<>();
            updateWrapper1.lambda().eq(YkfAccountInputRecordEntity::getAccountNo, subAccount1.getAccountNo())
                    .ge(YkfAccountInputRecordEntity::getDate, ykfCustomerSubAccount.getStartDate())
                    .le(YkfAccountInputRecordEntity::getDate, ykfCustomerSubAccount.getEndDate())
                    .set(YkfAccountInputRecordEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId());
            inputRecordService.update(updateWrapper1);
        }
        return R.ok();
    }


    /**
     * 添加临时用户
     */
    @PostMapping("/addTemporaryCustomer")
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public R addTemporaryCustomer(@RequestBody YkfCustomerSubAccountEntity ykfCustomerSubAccount) {
        if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount) && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getSubAccountId())
                && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getStartDate())
                && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getEndDate())
                && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getUserId())) {
            //校验日期返回是否在子账号范围内
            YkfCustomerSubAccountEntity subAccount = ykfCustomerSubAccountService.getById(ykfCustomerSubAccount.getSubAccountId());
            Date start = subAccount.getStartDate();
            Date end = subAccount.getEndDate();
            if (ykfCustomerSubAccount.getStartDate().compareTo(start) < 0) {
                throw new RRException("临时分配客服开始日期应大于等于原分配客服开始日期");
            }
            if (ykfCustomerSubAccount.getEndDate().compareTo(end) > 0) {
                throw new RRException("临时分配客服结束日期应小于等于原分配客服结束日期");
            }
            if (ykfCustomerSubAccount.getStartDate().compareTo(start) == 0) {
                //删除原子账号分配记录
                ykfCustomerSubAccountService.removeById(ykfCustomerSubAccount.getSubAccountId());
            } else {
                //更新原子账号结束日期
                DateTime oldCustomerEndDate = DateUtil.offsetDay(ykfCustomerSubAccount.getStartDate(), -1);
                UpdateWrapper<YkfCustomerSubAccountEntity> updateWrapper = new UpdateWrapper<>();
                updateWrapper.lambda().eq(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId())
                        .set(YkfCustomerSubAccountEntity::getEndDate, oldCustomerEndDate);
                ykfCustomerSubAccountService.update(updateWrapper);
            }

            //新增临时子账号分配记录
            YkfCustomerSubAccountEntity temporaryCustomerSubAccount = new YkfCustomerSubAccountEntity();
            BeanUtil.copyProperties(subAccount, temporaryCustomerSubAccount);
            temporaryCustomerSubAccount.setSubAccountId(null);
            temporaryCustomerSubAccount.setCreateUserId(null);
            temporaryCustomerSubAccount.setCreateUserName(null);
            temporaryCustomerSubAccount.setCreateTime(null);
            temporaryCustomerSubAccount.setUpdateUserId(null);
            temporaryCustomerSubAccount.setUpdateUserName(null);
            temporaryCustomerSubAccount.setUpdateTime(null);
            temporaryCustomerSubAccount.setStartDate(ykfCustomerSubAccount.getStartDate());
            temporaryCustomerSubAccount.setEndDate(ykfCustomerSubAccount.getEndDate());
            temporaryCustomerSubAccount.setCompanyNo(ykfCustomerSubAccount.getCompanyNo());
            temporaryCustomerSubAccount.setCompanyName(ykfCustomerSubAccount.getCompanyName());
            temporaryCustomerSubAccount.setUserId(ykfCustomerSubAccount.getUserId());
            SysUserEntity sysUser = sysUserService.getById(ykfCustomerSubAccount.getUserId());
            if (ObjectUtil.isNotEmpty(sysUser)) {
                temporaryCustomerSubAccount.setName(sysUser.getName());
                temporaryCustomerSubAccount.setFlowerName(sysUser.getFlowerName());
                temporaryCustomerSubAccount.setMobile(sysUser.getMobile());
                temporaryCustomerSubAccount.setCustomPostType(sysUser.getCustomPostType());
                temporaryCustomerSubAccount.setCustomPostTypeName(sysUser.getCustomPostTypeName());
            }
            ykfCustomerSubAccountService.save(temporaryCustomerSubAccount);
            //更新日期范围内数据所属
            UpdateWrapper<YkfAccountInputRecordEntity> inputRecordUpdateWrapper = new UpdateWrapper<>();
            inputRecordUpdateWrapper.lambda().eq(YkfAccountInputRecordEntity::getAccountNo, subAccount.getAccountNo())
                    .ge(YkfAccountInputRecordEntity::getDate, ykfCustomerSubAccount.getStartDate())
                    .le(YkfAccountInputRecordEntity::getDate, ykfCustomerSubAccount.getEndDate())
                    .set(YkfAccountInputRecordEntity::getSubAccountId, temporaryCustomerSubAccount.getSubAccountId());
            inputRecordService.update(inputRecordUpdateWrapper);

            if (ykfCustomerSubAccount.getEndDate().compareTo(end) != 0) {
                //新增原子账号新的分配记录
                DateTime oldCustomerStartDate = DateUtil.offsetDay(ykfCustomerSubAccount.getEndDate(), 1);
                YkfCustomerSubAccountEntity oldCustomerSubAccount = new YkfCustomerSubAccountEntity();
                BeanUtil.copyProperties(subAccount, oldCustomerSubAccount);
                oldCustomerSubAccount.setSubAccountId(null);
                oldCustomerSubAccount.setCreateUserId(null);
                oldCustomerSubAccount.setCreateUserName(null);
                oldCustomerSubAccount.setCreateTime(null);
                oldCustomerSubAccount.setUpdateUserId(null);
                oldCustomerSubAccount.setUpdateUserName(null);
                oldCustomerSubAccount.setUpdateTime(null);
                oldCustomerSubAccount.setStartDate(oldCustomerStartDate);
                oldCustomerSubAccount.setEndDate(end);
                ykfCustomerSubAccountService.save(oldCustomerSubAccount);
                //更新日期范围内数据所属
                UpdateWrapper<YkfAccountInputRecordEntity> inputRecordUpdateWrapper2 = new UpdateWrapper<>();
                inputRecordUpdateWrapper2.lambda().eq(YkfAccountInputRecordEntity::getAccountNo, subAccount.getAccountNo())
                        .ge(YkfAccountInputRecordEntity::getDate, oldCustomerStartDate)
                        .le(YkfAccountInputRecordEntity::getDate, end)
                        .set(YkfAccountInputRecordEntity::getSubAccountId, temporaryCustomerSubAccount.getSubAccountId());
                inputRecordService.update(inputRecordUpdateWrapper2);
            }
        } else {
            throw new RRException("参数缺失");
        }
        return R.ok();
    }

    /**
     * 分配子公司
     */
    @PostMapping("/distributeCompany")
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public R distributeCompany(@RequestBody YkfCustomerSubAccountEntity ykfCustomerSubAccount) throws ClientException {
        // (1) 校验,提交过来的子账号对象、子账号ID、分公司都不能为空
        if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount) && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getSubAccountId()) && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getCompanyNo())) {
            // 根据子账号id获取子账号对象
            YkfCustomerSubAccountEntity subAccount1 = ykfCustomerSubAccountService.getById(ykfCustomerSubAccount.getSubAccountId());

            // 前端提交的子账号和数据库取到的子账号对象做校验
            validRepeatTime(subAccount1, ykfCustomerSubAccount);

            // 如果没有日期没有冲突,开始日期不为null并且结束日期都为null,强行把结束日期改为2188-01-01
            if (ObjectUtil.isNotNull(ykfCustomerSubAccount.getStartDate()) && ObjectUtil.isNull(ykfCustomerSubAccount.getEndDate())) {
                ykfCustomerSubAccount.setEndDate(DateUtil.parseDate("2188-01-01"));
            }
            Long accountId = null;
            String accountNo = "";
            if (StrUtil.isBlank(subAccount1.getCompanyNo())) {
                // 如果这个子账号没有分配公司,则是更新
                accountId = ykfCustomerSubAccount.getSubAccountId();
                accountNo = ykfCustomerSubAccount.getAccountNo();
                UpdateWrapper<YkfCustomerSubAccountEntity> updateWrapper = new UpdateWrapper<>();
                SysUserEntity user = CommonUtils.getUser();
                updateWrapper.lambda().eq(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId())
                        .set(YkfCustomerSubAccountEntity::getAllocationRuleId, ykfCustomerSubAccount.getAllocationRuleId())
                        .set(YkfCustomerSubAccountEntity::getUserId, ykfCustomerSubAccount.getUserId())
                        .set(YkfCustomerSubAccountEntity::getCompanyNo, ykfCustomerSubAccount.getCompanyNo())
                        .set(YkfCustomerSubAccountEntity::getCompanyName, ykfCustomerSubAccount.getCompanyName())
                        .set(YkfCustomerSubAccountEntity::getStartDate, ykfCustomerSubAccount.getStartDate())
                        .set(YkfCustomerSubAccountEntity::getEndDate, ykfCustomerSubAccount.getEndDate())
                        .set(YkfCustomerSubAccountEntity::getCommissionRatio, ykfCustomerSubAccount.getCommissionRatio())
                        .set(YkfCustomerSubAccountEntity::getSendSmsSign, ykfCustomerSubAccount.getSendSmsSign())
                        .set(YkfCustomerSubAccountEntity::getAllocationRuleName, ykfCustomerSubAccount.getAllocationRuleName())
                        //公司底薪
                        .set(YkfCustomerSubAccountEntity::getCompanyBaseSalary, ykfCustomerSubAccount.getConventionSalary())
                        .set(YkfCustomerSubAccountEntity::getHeadDispatchName, user.getFlowerName());
                if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getUserId())) {
                    SysUserEntity sysUser = sysUserService.getById(ykfCustomerSubAccount.getUserId());
                    if (ObjectUtil.isNotEmpty(sysUser)) {
                        updateWrapper.lambda().set(YkfCustomerSubAccountEntity::getName, sysUser.getName())
                                .set(YkfCustomerSubAccountEntity::getFlowerName, sysUser.getFlowerName())
                                .set(YkfCustomerSubAccountEntity::getMobile, sysUser.getMobile())
                                .set(YkfCustomerSubAccountEntity::getCustomPostType, sysUser.getCustomPostType())
                                .set(YkfCustomerSubAccountEntity::getCustomPostTypeName, sysUser.getCustomPostTypeName());
                    }
                }
                ykfCustomerSubAccountService.update(new YkfCustomerSubAccountEntity(), updateWrapper);
            } else {
                // 已分配公司

                // 先把主键设置为null
                subAccount1.setSubAccountId(null);
                // 保存新数据

                // 定义一个新的子账号对象
                YkfCustomerSubAccountEntity saveSubAccount = new YkfCustomerSubAccountEntity();

                // 合并从数据取的对象和新new的对象
                BeanUtil.copyProperties(subAccount1, saveSubAccount);
                // 再次把主键设置为null
                saveSubAccount.setSubAccountId(null);

                // 组装对象(把页面的数据set进新对象中)
                saveSubAccount.setAllocationRuleId(ykfCustomerSubAccount.getAllocationRuleId());
                saveSubAccount.setUserId(ykfCustomerSubAccount.getUserId());
                saveSubAccount.setExName(ykfCustomerSubAccount.getExName());
                saveSubAccount.setExNameLabel(ykfCustomerSubAccount.getExNameLabel());
                saveSubAccount.setStartDate(ykfCustomerSubAccount.getStartDate());
                saveSubAccount.setEndDate(ykfCustomerSubAccount.getEndDate());
                saveSubAccount.setCompanyBaseSalary(ykfCustomerSubAccount.getConventionSalary());
                saveSubAccount.setCommissionRatio(ykfCustomerSubAccount.getCommissionRatio());
                saveSubAccount.setSendSmsSign(ykfCustomerSubAccount.getSendSmsSign());
                saveSubAccount.setAllocationRuleName(ykfCustomerSubAccount.getAllocationRuleName());
                SysUserEntity sysUser = sysUserService.getById(ykfCustomerSubAccount.getUserId());
                if (ObjectUtil.isNotEmpty(sysUser)) {
                    saveSubAccount.setName(sysUser.getName());
                    saveSubAccount.setFlowerName(sysUser.getFlowerName());
                    saveSubAccount.setMobile(sysUser.getMobile());
                    saveSubAccount.setCustomPostType(sysUser.getCustomPostType());
                    saveSubAccount.setCustomPostTypeName(sysUser.getCustomPostTypeName());
                    saveSubAccount.setCompanyNo(sysUser.getCompanyNo());
                    saveSubAccount.setCompanyName(sysUser.getCompanyName());
                }
                SysUserEntity user = CommonUtils.getUser();
                saveSubAccount.setHeadDispatchName(user.getFlowerName());
                // 新增数据
                ykfCustomerSubAccountService.save(saveSubAccount);
                accountId = saveSubAccount.getSubAccountId();
                accountNo = saveSubAccount.getAccountNo();
            }
            // 客服分配不为空，则更新数据表，将所有这个子账号数据指向最新的子账号记录
            if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getUserId())) {
                UpdateWrapper<YkfAccountInputRecordEntity> updateWrapper1 = new UpdateWrapper<>();
                updateWrapper1.lambda().eq(YkfAccountInputRecordEntity::getAccountNo, accountNo)
                        .ge(YkfAccountInputRecordEntity::getDate, ykfCustomerSubAccount.getStartDate())
                        .le(YkfAccountInputRecordEntity::getDate, ykfCustomerSubAccount.getEndDate())
                        .set(YkfAccountInputRecordEntity::getSubAccountId, accountId);
                inputRecordService.update(updateWrapper1);
            }
        }
        return R.ok();
    }

    public static void main(String[] args) {
        YkfCustomerSubAccountEntity ykfCustomerSubAccountEntity = new YkfCustomerSubAccountEntity();
        ykfCustomerSubAccountEntity.setCompanyNo("aaa");
        System.out.println(ObjectUtil.isNotEmpty(ykfCustomerSubAccountEntity));
    }

    /**
     * 子账号分配-删除
     */
    @PostMapping("/deleteSubAccount")
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public R deleteSubAccount(@RequestBody YkfCustomerSubAccountEntity ykfCustomerSubAccount) {
        if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount) && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getSubAccountId())) {
            YkfCustomerSubAccountEntity subAccount = ykfCustomerSubAccountService.getById(ykfCustomerSubAccount.getSubAccountId());
            //查询是否存在记录
            if (ObjectUtil.isNotEmpty(subAccount.getStartDate()) && ObjectUtil.isNotEmpty(subAccount.getEndDate())) {
                QueryWrapper<YkfAccountInputRecordEntity> queryWrapper = new QueryWrapper<>();
                //查询6个月之前的时间
                DateTime offset = DateUtil.offset(DateUtil.date(), DateField.MONTH, -6);
                queryWrapper.lambda().eq(YkfAccountInputRecordEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId())
                        .ge(YkfAccountInputRecordEntity::getDate, subAccount.getStartDate().compareTo(offset) > 0 ? subAccount.getStartDate() : offset)
                        .le(YkfAccountInputRecordEntity::getDate, subAccount.getEndDate());
                if (inputRecordService.count(queryWrapper) > 0) {
                    throw new RRException("最近6个月有数据不可以删除");
                }
            }
            QueryWrapper<YkfCustomerSubAccountEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().eq(YkfCustomerSubAccountEntity::getAccountNo, subAccount.getAccountNo());
            if (ykfCustomerSubAccountService.count(queryWrapper) == 1) {
                YkfCustomerSubAccountEntity newSub = new YkfCustomerSubAccountEntity();
//            newSub.setSubAccountId(ykfCustomerSubAccount.getSubAccountId());
                newSub.setShopName(subAccount.getShopName());
                newSub.setShopNo(subAccount.getShopNo());
                newSub.setShopId(subAccount.getShopId());
//            newSub.setBaseSalary(subAccount.getBaseSalary());
                newSub.setCustomerId(subAccount.getCustomerId());
                newSub.setCustomerName(subAccount.getCustomerName());
                newSub.setAccountNo(subAccount.getAccountNo());
                newSub.setAccountName(subAccount.getAccountName());
                newSub.setAccountPassword(subAccount.getAccountPassword());
                newSub.setStatus(1);
                ykfCustomerSubAccountService.save(newSub);
            }
            ykfCustomerSubAccountService.removeById(ykfCustomerSubAccount.getSubAccountId());
            YkfSubAccountModifyRecordEntity record = new YkfSubAccountModifyRecordEntity();
            record.setSubAccountId(ykfCustomerSubAccount.getSubAccountId());
            record.setModifyContent("删除");
            record.setModifyBefore(subAccount.getFlowerName());
            record.setModifyAfter("");
            modifyRecordService.save(record);
        } else {
            throw new RRException("参数缺失");
        }
        return R.ok();
    }


    /**
     * 子账号分配-撤销
     */
    @PostMapping("/revokeSubAccount")
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public R revokeSubAccount(@RequestBody YkfCustomerSubAccountEntity ykfCustomerSubAccount) {
//        if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount) && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getSubAccountId())) {
//            YkfCustomerSubAccountEntity subAccount = ykfCustomerSubAccountService.getById(ykfCustomerSubAccount.getSubAccountId());
//            YkfCustomerSubAccountEntity newSub = new YkfCustomerSubAccountEntity();
//
//            newSub.setSubAccountId(ykfCustomerSubAccount.getSubAccountId());
//            newSub.setShopName(subAccount.getShopName());
//            newSub.setShopNo(subAccount.getShopNo());
//            newSub.setBaseSalary(subAccount.getBaseSalary());
//            newSub.setCustomerId(subAccount.getCustomerId());
//            newSub.setCustomerName(subAccount.getCustomerName());
//            newSub.setStatus(1);
//            ykfCustomerSubAccountService.removeById(ykfCustomerSubAccount.getSubAccountId());
//            ykfCustomerSubAccountService.save(newSub);
        if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount) && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getSubAccountId())) {
            YkfCustomerSubAccountEntity subAccount = ykfCustomerSubAccountService.getById(ykfCustomerSubAccount.getSubAccountId());
            //查询是否存在记录
            if (ObjectUtil.isNotEmpty(subAccount.getStartDate()) && ObjectUtil.isNotEmpty(subAccount.getEndDate())) {
                QueryWrapper<YkfSubAccountRecordEntity> queryWrapper = new QueryWrapper<>();
                queryWrapper.lambda().eq(YkfSubAccountRecordEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId())
                        .ge(YkfSubAccountRecordEntity::getStartDate, subAccount.getStartDate())
                        .le(YkfSubAccountRecordEntity::getEndDate, subAccount.getEndDate());
                if (subAccountRecordService.count(queryWrapper) > 0) {
                    throw new RRException("周期内已录入服务数据,不能撤销");
                }
            }
            QueryWrapper<YkfCustomerSubAccountEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().eq(YkfCustomerSubAccountEntity::getAccountNo, subAccount.getAccountNo());
            if (ykfCustomerSubAccountService.count(queryWrapper) == 1) {
                YkfCustomerSubAccountEntity newSub = new YkfCustomerSubAccountEntity();
//            newSub.setSubAccountId(ykfCustomerSubAccount.getSubAccountId());
                newSub.setShopName(subAccount.getShopName());
                newSub.setShopNo(subAccount.getShopNo());
                newSub.setShopId(subAccount.getShopId());
//            newSub.setBaseSalary(subAccount.getBaseSalary());
                newSub.setCustomerId(subAccount.getCustomerId());
                newSub.setCustomerName(subAccount.getCustomerName());
                newSub.setAccountNo(subAccount.getAccountNo());
                newSub.setAccountName(subAccount.getAccountName());
                newSub.setAccountPassword(subAccount.getAccountPassword());
                newSub.setStatus(1);
                ykfCustomerSubAccountService.save(newSub);
            }
            ykfCustomerSubAccountService.removeById(ykfCustomerSubAccount.getSubAccountId());
            YkfSubAccountModifyRecordEntity record = new YkfSubAccountModifyRecordEntity();
            record.setSubAccountId(ykfCustomerSubAccount.getSubAccountId());
            record.setModifyContent("撤销");
            record.setModifyBefore(subAccount.getFlowerName());
            record.setModifyAfter("");
            modifyRecordService.save(record);
        } else {
            throw new RRException("参数缺失");
        }
        return R.ok();
    }


    /**
     * 子账号分配-修改
     */
    @PostMapping("/modifyCusSer")
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public R modifyCusSer(@RequestBody YkfCustomerSubAccountEntity ykfCustomerSubAccount) {
        if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount) && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getSubAccountId())) {
            YkfCustomerSubAccountEntity oldSubAccount = ykfCustomerSubAccountService.getById(ykfCustomerSubAccount.getSubAccountId());
            validRepeatTime2(oldSubAccount, ykfCustomerSubAccount);
            UpdateWrapper<YkfCustomerSubAccountEntity> updateWrapper = new UpdateWrapper<>();
            updateWrapper.lambda().eq(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId());
            List<YkfSubAccountModifyRecordEntity> modifyRecordList = new ArrayList<>();
            boolean flag = false;
            //保存修改记录
            if (DateUtil.compare(oldSubAccount.getStartDate(), ykfCustomerSubAccount.getStartDate()) != 0) {
                updateWrapper.lambda().set(YkfCustomerSubAccountEntity::getStartDate, ykfCustomerSubAccount.getStartDate());
                YkfSubAccountModifyRecordEntity record = new YkfSubAccountModifyRecordEntity();
                record.setSubAccountId(ykfCustomerSubAccount.getSubAccountId());
                record.setModifyContent("开始日期");
                record.setModifyBefore(DateUtil.formatDate(oldSubAccount.getStartDate()));
                record.setModifyAfter(DateUtil.formatDate(ykfCustomerSubAccount.getStartDate()));
                modifyRecordList.add(record);
                flag = true;
            }
            if (ObjectUtil.isNull(oldSubAccount.getEndDate()) || oldSubAccount.getEndDate().compareTo(ykfCustomerSubAccount.getEndDate()) != 0) {
                updateWrapper.lambda().set(YkfCustomerSubAccountEntity::getEndDate, ykfCustomerSubAccount.getEndDate());
                YkfSubAccountModifyRecordEntity record = new YkfSubAccountModifyRecordEntity();
                record.setSubAccountId(ykfCustomerSubAccount.getSubAccountId());
                record.setModifyContent("结束日期");
                record.setModifyBefore(DateUtil.formatDate(oldSubAccount.getEndDate()));
                record.setModifyAfter(DateUtil.formatDate(ykfCustomerSubAccount.getEndDate()));
                modifyRecordList.add(record);
                flag = true;
            }
            if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getStartDate()) && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getEndDate())) {
                //校验日期是否重复,重复则报错
                QueryWrapper<YkfCustomerSubAccountEntity> queryWrapper = new QueryWrapper<>();
                queryWrapper.lambda().eq(YkfCustomerSubAccountEntity::getAccountNo, oldSubAccount.getAccountNo())
                        .ne(YkfCustomerSubAccountEntity::getSubAccountId, oldSubAccount.getSubAccountId());
                List<YkfCustomerSubAccountEntity> list = ykfCustomerSubAccountService.list(queryWrapper);
                if (ObjectUtil.isNotEmpty(list)) {
                    for (YkfCustomerSubAccountEntity item : list) {
                        if (ObjectUtil.isNotEmpty(item.getStartDate()) && ObjectUtil.isNotEmpty(item.getEndDate())) {
                            if (!(ykfCustomerSubAccount.getEndDate().compareTo(item.getStartDate()) < 0 || ykfCustomerSubAccount.getStartDate().compareTo(item.getEndDate()) > 0)) {
                                throw new RRException("日期范围与其它分配记录存在重叠,请检查");
                            }
                        }
                    }
                }
                //更新数据
                UpdateWrapper<YkfAccountInputRecordEntity> updateWrapper1 = new UpdateWrapper<>();
                updateWrapper1.lambda().eq(YkfAccountInputRecordEntity::getAccountNo, oldSubAccount.getAccountNo())
                        .ge(YkfAccountInputRecordEntity::getDate, oldSubAccount.getStartDate())
                        .le(YkfAccountInputRecordEntity::getDate, oldSubAccount.getEndDate())
                        .set(YkfAccountInputRecordEntity::getSubAccountId, oldSubAccount.getSubAccountId());
                inputRecordService.update(updateWrapper1);
                flag = true;
            }

            if (ObjectUtil.isEmpty(oldSubAccount.getConventionSalary()) || oldSubAccount.getConventionSalary().compareTo(ykfCustomerSubAccount.getConventionSalary()) != 0) {
                boolean masterCompany = sysUserService.isMasterCompany();
                if (masterCompany) {
                    updateWrapper.lambda().set(YkfCustomerSubAccountEntity::getCompanyBaseSalary, ykfCustomerSubAccount.getConventionSalary());
                } else {
                    updateWrapper.lambda().set(YkfCustomerSubAccountEntity::getConventionSalary, ykfCustomerSubAccount.getConventionSalary());
                }
                YkfSubAccountModifyRecordEntity record = new YkfSubAccountModifyRecordEntity();
                record.setSubAccountId(ykfCustomerSubAccount.getSubAccountId());
                record.setModifyContent("约定分摊底薪");
                record.setModifyBefore(ObjectUtil.isEmpty(oldSubAccount.getConventionSalary()) ? "0" : oldSubAccount.getConventionSalary().toString());
                record.setModifyAfter(ykfCustomerSubAccount.getConventionSalary().toString());
                modifyRecordList.add(record);
                flag = true;
            }
            if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getCommissionRatio()) && (ObjectUtil.isEmpty(oldSubAccount.getCommissionRatio()) || oldSubAccount.getCommissionRatio().compareTo(ykfCustomerSubAccount.getCommissionRatio()) != 0)) {
                updateWrapper.lambda().set(YkfCustomerSubAccountEntity::getCommissionRatio, ykfCustomerSubAccount.getCommissionRatio());
                YkfSubAccountModifyRecordEntity record = new YkfSubAccountModifyRecordEntity();
                record.setSubAccountId(ykfCustomerSubAccount.getSubAccountId());
                record.setModifyContent("提成");
                record.setModifyBefore(ObjectUtil.isEmpty(oldSubAccount.getCommissionRatio()) ? "0" : oldSubAccount.getCommissionRatio().toString());
                record.setModifyAfter(ykfCustomerSubAccount.getCommissionRatio().toString());
                modifyRecordList.add(record);
                flag = true;
            }
            //修改客服
            if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getUserId())) {
                SysUserEntity sysUser = sysUserService.getById(ykfCustomerSubAccount.getUserId());
                if (ObjectUtil.isNotEmpty(sysUser)) {
                    SysUserEntity user = CommonUtils.getUser();
                    updateWrapper.lambda()
                            .set(YkfCustomerSubAccountEntity::getUserId, ykfCustomerSubAccount.getUserId())
                            .set(YkfCustomerSubAccountEntity::getName, sysUser.getName())
                            .set(YkfCustomerSubAccountEntity::getFlowerName, sysUser.getFlowerName())
                            .set(YkfCustomerSubAccountEntity::getMobile, sysUser.getMobile())
                            .set(YkfCustomerSubAccountEntity::getCustomPostType, sysUser.getCustomPostType())
                            .set(YkfCustomerSubAccountEntity::getCustomPostTypeName, sysUser.getCustomPostTypeName())
                            .set(YkfCustomerSubAccountEntity::getCreateUserId, user.getUserId())
                            .set(YkfCustomerSubAccountEntity::getCreateUserName, user.getName());
                    flag = true;
                }
            }
            if (!flag) {
                return R.ok();
            }
            ykfCustomerSubAccountService.update(new YkfCustomerSubAccountEntity(), updateWrapper);

            if (modifyRecordList.size() > 0) {
                modifyRecordService.saveBatch(modifyRecordList);
            }
        } else {
            throw new RRException("参数缺失");
        }
        return R.ok();
    }

    /**
     * 子账号修改记录
     */
    @PostMapping("/modifyRecordList")
    public R modifyRecordList(@RequestBody YkfCustomerSubAccountEntity ykfCustomerSubAccount) {
        if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount) && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getSubAccountId())) {
            QueryWrapper<YkfSubAccountModifyRecordEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().eq(YkfSubAccountModifyRecordEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId())
                    .orderByDesc(YkfSubAccountModifyRecordEntity::getCreateTime);
            List<YkfSubAccountModifyRecordEntity> list = modifyRecordService.list(queryWrapper);
            return R.ok(list);
        } else {
            throw new RRException("参数缺失");
        }
    }

    /**
     * @param subAccount            数据库取到的子账号对象
     * @param ykfCustomerSubAccount 前端提交的子账号对象
     */
    public void validRepeatTime(YkfCustomerSubAccountEntity subAccount, YkfCustomerSubAccountEntity ykfCustomerSubAccount) {
        // 判断前端提交的开始日期是否为null,如果不为null进入校验
        if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getStartDate())) {
            // 如果分配子公司时提交了开始时间，那么这个开始日期就不能小于店铺的开始日期
            Long shopId = subAccount.getShopId();
            YkfCustomerShopEntity shop = shopService.getById(shopId);
            if (ykfCustomerSubAccount.getStartDate().compareTo(shop.getStartDate()) < 0) {
                throw new RRException("子账号分配选择开始日期不能早于店铺管理的开始日期");
            }
        }

        // 取出所有account_no是subAccount.getAccountNo()的数据并根据startDate进行正序排序
        QueryWrapper<YkfCustomerSubAccountEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(YkfCustomerSubAccountEntity::getAccountNo, subAccount.getAccountNo());
        queryWrapper.lambda().orderByAsc(YkfCustomerSubAccountEntity::getStartDate);
        List<YkfCustomerSubAccountEntity> list = ykfCustomerSubAccountService.list(queryWrapper);

        // 判断是不是找到了子账号集合
        if (ObjectUtil.isNotEmpty(list)) {
            // 循环子账号集合
            for (int i = 0; i < list.size(); i++) {
                // 取到当前的子账号集合的某个子账号对象
                YkfCustomerSubAccountEntity item = list.get(i);
                // 如果子账号没有开始日期,就continue
                if (ObjectUtil.isEmpty(item.getStartDate())) {
                    continue;
                }

                if (i != list.size() - 1) {
                    // 如果不是最后一次循环
                    // 分配公司时的开始时间和结束时间不能跟这个子账号其它的分配记录日期重叠，只能在之前或者之后(现在分配公司时可以直接分配客服)
                    if ((ykfCustomerSubAccount.getStartDate().compareTo(item.getStartDate()) < 0 && ykfCustomerSubAccount.getEndDate().compareTo(item.getStartDate()) < 0)
                            || (ykfCustomerSubAccount.getStartDate().compareTo(item.getEndDate()) > 0 && ykfCustomerSubAccount.getEndDate().compareTo(item.getEndDate()) > 0)) {
                        continue;
                        // 没有日期冲突，继续检查下一个账号
                    } else {
                        // 有日期冲突，抛出异常
                        throw new RRException("请检查起止日期是否与其它分配冲突！");
                    }
                } else {
                    // 最后一个的endDate是2188-01-01
                    if (ObjectUtil.isNotEmpty(item.getStartDate()) && item.getStartDate().compareTo(ykfCustomerSubAccount.getStartDate()) >= 0) {
                        // 再次检查日期范围是否冲突
                        if ((ykfCustomerSubAccount.getStartDate().compareTo(item.getStartDate()) < 0 && ykfCustomerSubAccount.getEndDate().compareTo(item.getStartDate()) < 0)
                                || (ykfCustomerSubAccount.getStartDate().compareTo(item.getEndDate()) > 0 && ykfCustomerSubAccount.getEndDate().compareTo(item.getEndDate()) > 0)) {
                            continue;
                        } else {
                            throw new RRException("请检查起止日期是否与其它分配冲突！");
                        }
                    } else {
                        // 如果当前账号的开始日期小于新账号的开始日期,那就修改2188为新账号开始日期的前一天
                        if (ObjectUtil.isNotEmpty(item.getEndDate())) {
                            if (item.getEndDate().compareTo(ykfCustomerSubAccount.getStartDate()) >= 0) {
                                // 如果新分配的那个子账号的开始日期大于
                                // 需要调整当前账号的结束日期，使其在新账号开始日期前一天
                                UpdateWrapper<YkfCustomerSubAccountEntity> updateWrapper = new UpdateWrapper<>();
                                updateWrapper.lambda().eq(YkfCustomerSubAccountEntity::getSubAccountId, item.getSubAccountId())
                                        .set(YkfCustomerSubAccountEntity::getEndDate, DateUtil.offsetDay(ykfCustomerSubAccount.getStartDate(), -1));
                                ykfCustomerSubAccountService.update(new YkfCustomerSubAccountEntity(), updateWrapper);
                            }
                        }
                    }
                }
            }
        }
    }

    public void validRepeatTime3(YkfCustomerSubAccountEntity subAccount, YkfCustomerSubAccountEntity ykfCustomerSubAccount) {
        if (ObjectUtil.isEmpty(subAccount.getStartDate()) || ObjectUtil.isEmpty(subAccount.getEndDate())) {
            throw new RRException("总公司暂未分配开始时间结束时间，请检查");
        }
        if (ykfCustomerSubAccount.getStartDate().compareTo(subAccount.getStartDate()) < 0) {
            throw new RRException("开始时间应大于总公司分配的开始时间，请检查");
        }
        if (ykfCustomerSubAccount.getEndDate().compareTo(subAccount.getEndDate()) > 0) {
            throw new RRException("结束时间应小于总公司分配的结束时间，请检查");
        }
        //查询所有子账号
//        QueryWrapper<YkfCustomerSubAccountEntity> queryWrapper = new QueryWrapper<>();
//        queryWrapper.lambda().eq(YkfCustomerSubAccountEntity::getAccountNo, subAccount.getAccountNo());
//        if (ObjectUtil.isNotEmpty(subAccount.getUserId())) {
//            queryWrapper.lambda().ne(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId());
//        }
//        else {
//            queryWrapper.lambda().ne(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId());
//        }
//        queryWrapper.lambda().ne(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId());
//        queryWrapper.lambda().orderByAsc(YkfCustomerSubAccountEntity::getStartDate);
//        List<YkfCustomerSubAccountEntity> list = ykfCustomerSubAccountService.list(queryWrapper);
//        if (ObjectUtil.isNotEmpty(list)) {
//            for (int i = 0; i < list.size(); i++) {
//                YkfCustomerSubAccountEntity item = list.get(i);
//                if (i != list.size() - 1) {
//                    if ((ykfCustomerSubAccount.getStartDate().compareTo(item.getStartDate()) < 0 && ykfCustomerSubAccount.getEndDate().compareTo(item.getStartDate()) < 0)
//                            || (ykfCustomerSubAccount.getStartDate().compareTo(item.getEndDate()) > 0 && ykfCustomerSubAccount.getEndDate().compareTo(item.getEndDate()) > 0)) {
//                        continue;
//                    } else {
//                        throw new RRException("请检查起止日期是否与其它分配冲突！");
//                    }
//                } else {
//                    if (ObjectUtil.isNotEmpty(item.getStartDate()) && item.getStartDate().compareTo(ykfCustomerSubAccount.getStartDate()) >= 0) {
//                        if ((ykfCustomerSubAccount.getStartDate().compareTo(item.getStartDate()) < 0 && ykfCustomerSubAccount.getEndDate().compareTo(item.getStartDate()) < 0)
//                                || (ykfCustomerSubAccount.getStartDate().compareTo(item.getEndDate()) > 0 && ykfCustomerSubAccount.getEndDate().compareTo(item.getEndDate()) > 0)) {
//                            continue;
//                        } else {
//                            throw new RRException("请检查起止日期是否与其它分配冲突！");
//                        }
//                    } else {
//                        if (ObjectUtil.isNotEmpty(item.getEndDate())) {
//                            if (item.getEndDate().compareTo(ykfCustomerSubAccount.getStartDate()) >= 0) {
//                                //更新之前的子账号
//                                UpdateWrapper<YkfCustomerSubAccountEntity> updateWrapper = new UpdateWrapper<>();
//                                updateWrapper.lambda().eq(YkfCustomerSubAccountEntity::getSubAccountId, item.getSubAccountId())
//                                        .set(YkfCustomerSubAccountEntity::getEndDate, DateUtil.offsetDay(ykfCustomerSubAccount.getStartDate(), -1));
//                                ykfCustomerSubAccountService.update(updateWrapper);
//                            }
//                        }
//                    }
//                }
//            }
//
//        }
    }

    private void validRepeatTime2(YkfCustomerSubAccountEntity subAccount, YkfCustomerSubAccountEntity ykfCustomerSubAccount) {
        if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getStartDate())) {
            Long shopId = subAccount.getShopId();
            YkfCustomerShopEntity shop = shopService.getById(shopId);
            if (ykfCustomerSubAccount.getStartDate().compareTo(shop.getStartDate()) < 0) {
                throw new RRException("子账号分配选择开始日期不能早于店铺管理的开始日期");
            }
        }
        //查询所有子账号
        QueryWrapper<YkfCustomerSubAccountEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(YkfCustomerSubAccountEntity::getAccountNo, subAccount.getAccountNo())
                .ne(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId());
//        if (ObjectUtil.isNotEmpty(subAccount.getUserId())) {
//            queryWrapper.lambda().ne(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId());
//        } else {
//            queryWrapper.lambda().ne(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId());
//        }
//        queryWrapper.lambda().ne(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId());
        List<YkfCustomerSubAccountEntity> list = ykfCustomerSubAccountService.list(queryWrapper);
        if (ObjectUtil.isNotEmpty(list)) {
            for (YkfCustomerSubAccountEntity item : list) {
                if (ObjectUtil.isNotEmpty(item.getStartDate()) && ObjectUtil.isNotEmpty(item.getEndDate())) {
                    if ((ykfCustomerSubAccount.getStartDate().compareTo(item.getStartDate()) < 0 && ykfCustomerSubAccount.getEndDate().compareTo(item.getStartDate()) < 0)
                            || (ykfCustomerSubAccount.getStartDate().compareTo(item.getEndDate()) > 0 && ykfCustomerSubAccount.getEndDate().compareTo(item.getEndDate()) > 0)) {
                        continue;
                    } else {
                        throw new RRException("请检查起止日期是否与其它分配冲突！");
                    }
                }
            }
        }
    }
//
//    /**
//     * 分配客服
//     */
//    @PostMapping("/distributeCusSer")
//    public R distributeCusSer(@RequestBody YkfCustomerSubAccountEntity ykfCustomerSubAccount){
//        if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount) && ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getSubAccountId())) {
//            UpdateWrapper<YkfCustomerSubAccountEntity> updateWrapper = new UpdateWrapper<>();
//            updateWrapper.lambda().eq(YkfCustomerSubAccountEntity::getSubAccountId, ykfCustomerSubAccount.getSubAccountId())
//                    .set(YkfCustomerSubAccountEntity::getAllocationRuleId, ykfCustomerSubAccount.getAllocationRuleId())
//                    .set(YkfCustomerSubAccountEntity::getUserId, ykfCustomerSubAccount.getUserId())
//                    .set(YkfCustomerSubAccountEntity::getExName, ykfCustomerSubAccount.getExName())
//                    .set(YkfCustomerSubAccountEntity::getExNameLabel, ykfCustomerSubAccount.getExNameLabel())
//                    .set(YkfCustomerSubAccountEntity::getStartDate, ykfCustomerSubAccount.getStartDate())
//                    .set(YkfCustomerSubAccountEntity::getEndDate, ykfCustomerSubAccount.getEndDate())
//                    .set(YkfCustomerSubAccountEntity::getConventionSalary, ykfCustomerSubAccount.getConventionSalary())
//                    .set(YkfCustomerSubAccountEntity::getCommissionRatio, ykfCustomerSubAccount.getCommissionRatio())
//                    .set(YkfCustomerSubAccountEntity::getSendSmsSign, ykfCustomerSubAccount.getSendSmsSign());
//            if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getSubAccountId())) {
//                YkfCustomerSubAccountEntity subAccount = ykfCustomerSubAccountService.getById(ykfCustomerSubAccount.getSubAccountId());
//                if (ObjectUtil.isNotEmpty(subAccount)) {
//                    updateWrapper.lambda().set(YkfCustomerSubAccountEntity::getAllocationRuleName, ykfCustomerSubAccount.getAllocationRuleName());
//                }
//            }
//            if (ObjectUtil.isNotEmpty(ykfCustomerSubAccount.getUserId())) {
//                SysUserEntity sysUser = sysUserService.getById(ykfCustomerSubAccount.getUserId());
//                if (ObjectUtil.isNotEmpty(sysUser)) {
//                    updateWrapper.lambda().set(YkfCustomerSubAccountEntity::getName, sysUser.getName())
//                            .set(YkfCustomerSubAccountEntity::getFlowerName, sysUser.getFlowerName());
//                }
//            }
//            ykfCustomerSubAccountService.update(updateWrapper);
//
//            //保存记录
//            Long subAccountId = ykfCustomerSubAccount.getSubAccountId();
//            YkfCustomerSubAccountEntity subAccount = ykfCustomerSubAccountService.getById(subAccountId);
//            YkfSubAccountRecordEntity subAccountRecord = new YkfSubAccountRecordEntity();
//            BeanUtil.copyProperties(subAccount, subAccountRecord);
//            subAccountRecord.setCreateTime(DateUtil.date());
//            subAccountRecordService.save(subAccountRecord);
//
//            if (ykfCustomerSubAccount.getSendSmsSign() == 1) {
//                //TODO 发送消息
//                //保存记录
//                YkfMsgRecordEntity record = new YkfMsgRecordEntity();
//                record.setStatus(1);
//                record.setMobile(subAccount.getMobile());
//                record.setPreSendTime(DateUtil.date());
//                record.setSendTime(DateUtil.date());
//                record.setRecordTime(DateUtil.date());
//                recordService.save(record);
//            } else if (ykfCustomerSubAccount.getSendSmsSign() == 2) {
//                //保存记录
//                YkfMsgRecordEntity record = new YkfMsgRecordEntity();
//                record.setStatus(0);
//                record.setMobile(subAccount.getMobile());
//                record.setPreSendTime(DateUtil.offsetHour(DateUtil.date(), 3));
//                record.setRecordTime(DateUtil.date());
//                recordService.save(record);
//            }
//        }
//        return R.ok();
//    }

    /**
     * 信息
     */
    @PostMapping("/shopSubAccountInfo")
    public R shopSubAccountInfo(@RequestBody YkfCustomerSubAccountEntity params) {
        if (ObjectUtil.isEmpty(params) || ObjectUtil.isEmpty(params.getShopId())) {
            throw new RRException("参数缺失");
        }
        YkfCustomerShopEntity shop = shopService.getById(params.getShopId());
        if (ObjectUtil.isNotEmpty(shop)) {
            YkfCustomerEntity customerEntity = customerService.getById(shop.getCustomerId());
            if (ObjectUtil.isNotEmpty(customerEntity)) {
                shop.setCustomerNo(customerEntity.getCustomerNo());
            }
            QueryWrapper<YkfCustomerSubAccountEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().eq(YkfCustomerSubAccountEntity::getShopId, params.getShopId())
                    .eq(YkfCustomerSubAccountEntity::getStatus, "1");
            List<YkfCustomerSubAccountEntity> list = ykfCustomerSubAccountService.list(queryWrapper);
            shop.setSubAccountList(list);
        }
        return R.ok(shop);
    }


    /**
     * 信息
     */
    @PostMapping("/sumSubAccount")
    public R sumSubAccount(@RequestBody ParamsModel<SumSubAccountModel> params) {
        PageUtils page = ykfCustomerSubAccountService.sumSubAccount(params);
        return R.ok(page);
    }

}
